<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1,user-scalable=0,viewport-fit=cover">
<meta name="wechat-enable-text-zoom-em" content="true">
<title>题库</title>
<script type="text/javascript" src="/oesc/jquery/jquery-1.7.2.min.js"></script>
<link rel="stylesheet" href="css/common.css"/>
</head>
<body>


  <div class='item'>
    <h3 class='title'>1、有关语句 "Student  *ss=new  Student[2];delete[]ss;"的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、delete[]ss  释放动态对象数组</li><li>B、delete[]ss  调用3次析构函数</li><li>C、new  Student[2]分配8个字节的内存</li><li>D、new  Student[2]调用一次构造函数</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>2、关于纯虛函数和抽象类的描述中，错误的是（　　）。</h3>
    <ul>
    <li>A、纯虚函数是--种特殊的虚函数，它没有具体实现</li><li>B、抽象类-般作为基类使用，其纯虚函数的实现由派生类给出</li><li>C、抽象类中一定具有一个或多个纯虚函数</li><li>D、抽象类的派生类中一定不会再有纯虛函数</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>3、对ignore()成员函数原型“istream  & ignore(int  n= 1,int  delim=EOF);”描述正确的是（　　）。</h3>
    <ul>
    <li>A、跳过输出流中的n个字符</li><li>B、跳过delim及其之后的所有字符.</li><li>C、常用于跳过输出中的无效部分</li><li>D、cin.ignore()等效于cin.ignore(1,EOF)</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>4、下列选项中属于面向对象程序设计思想的是（　　）。</h3>
    <ul>
    <li>A、采用自顶向下、逐步求精及模块化的思想</li><li>B、把逻辑功能完全独立或相对独立的程序部分设计成函数</li><li>C、把问题看成相互作用的事物的集合</li><li>D、解决问题的焦点集中于函数的设计与相互的调用上</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>5、下列流类中，可以用于输入/输出的是（　　）。</h3>
    <ul>
    <li>A、ios</li><li>B、fstream</li><li>C、iostream</li><li>D、strstream</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>6、已知类A中一个成员函数说明 " void  Set(A &a);" ，其中A &a的含义是（　　）。</h3>
    <ul>
    <li>A、指向类A的指针为a</li><li>B、将a的地址值赋给变量Set</li><li>C、a是类A的对象引用，用来作函数Set()的形参</li><li>D、变量A与a按位相与作为函数Set()的参数</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>7、下列关于静态数据成员的特性叙述中，错误的是（　　）。</h3>
    <ul>
    <li>A、说明静态数据成员时使用关键字static进行修饰</li><li>B、静态数据成员要在类外进行初始化</li><li>C、引用静态数据成员时，要在静态数据成员名前加 <类名 >和作用城运算符</li><li>D、静态数据成员是所有对象的共享成员</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>8、以下不能正确创建输出文件对象并使其与磁盘文件相关联的语句是（　　）。</h3>
    <ul>
    <li>A、ofstream  myfile;myfile.open("ofile.txt ");</li><li>B、ofstream  *myfile= new  ofstream;myfile->open("ofile.txt ");</li><li>C、ofstream  myfile.open("ofile.txt ");</li><li>D、ofstream  *myfile=new("ofile.txt ");</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>9、下列关于C++语言类库提供输入流类和输出流类的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、输入流类ostream</li><li>B、输出流类istream</li><li>C、cin是istream类的对象</li><li>D、cout是istream类的对象</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>10、决定C++中函数的返回值类型的是（　　）。
                                          虽的阴而结合不干风，</h3>
    <ul>
    <li>A、return  语句中的表达式类型</li><li>B、调用该函数时系统随机产生的类型</li><li>C、调用该函数时的主调用函数类型</li><li>D、在定义函数时所指定的类型</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>11、当派生类私有继承基类时，基类中的公有成员和保护成员成为派生类的（　　）。</h3>
    <ul>
    <li>A、public  成员</li><li>B、private  成员</li><li>C、protected  成员</li><li>D、友元</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>12、假设myDate类中仅定义了构造函数“myDate:myDate(int  y= 1981, int  m  = 2, int  d=18){year=y; month=m; day=d;}"， 创建对象时若使用形式“myDate  d1(2010);”，则输出这个对象的值是（　　）。</h3>
    <ul>
    <li>A、1981</li><li>B、1981/2/18</li><li>C、2010</li><li>D、2010/2/18</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>13、通常的拷贝初始化构造的参数是（　　）。</h3>
    <ul>
    <li>A、某个对象名</li><li>B、某个对象的成员名</li><li>C、某个对象的引用名</li><li>D、某个对象的指针名</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>14、C++允许重载大部分的内置运算符，下列选项中可重载的是（　　）。</h3>
    <ul>
    <li>A、!=</li><li>B、sizeof</li><li>C、?:</li><li>D、::</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>15、下面关于基类和派生类的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、一个类不能被多次说明为某个派生类的直接类，可以不止一次地成为间接基类</li><li>B、一个类可以被多次说明为某个派生类的直接类，可以不止一次地成为间接基类</li><li>C、--个类不能被多次说明为某个派生类的直接类，但只能成为一次间接基类</li><li>D、一个类可以被多次说明为某个派生类的直接类，但只能成为一次间接基类</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>16、以下基类中的成员函数表示纯虚函数的是（　　）。</h3>
    <ul>
    <li>A、virtual  void  tt() =0;</li><li>B、void  tt(int) =0;</li><li>C、virtual  void  tt( int) ;</li><li>D、virtual  void  t(int){}</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>17、面向对象程序设计语言与结构化程序设计语言最根本的不同之处在于（　　）。</h3>
    <ul>
    <li>A、使用了类</li><li>B、能够实现变量自动初始化</li><li>C、支持软件重用</li><li>D、支持接口重用</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>18、不属于面向对象程序设计特性的是（　　）。</h3>
    <ul>
    <li>A、抽象性</li><li>B、数据相关性</li><li>C、多态性</li><li>D、继承性</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>19、声明类时，下列说法正确的是（　　）。</h3>
    <ul>
    <li>A、可以在类的声明中给数据成员赋初值</li><li>B、数据成员的数据类型可以是register</li><li>C、private， public， protected  可以按任意顺序出现</li><li>D、没有用private， public， protected  定义的数据成员是公有成员</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>20、若有 "int  m  = 5;"，则下列表示引用的方法中，正确的是（　　）。</h3>
    <ul>
    <li>A、int  &Z;</li><li>B、int  &t=5;</li><li>C、int  &X  =m;</li><li>D、float  &f  = &m;</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>21、读一个C++数据文件，要创建的流对象是（　　）。</h3>
    <ul>
    <li>A、ifstream</li><li>B、ofstream</li><li>C、cin</li><li>D、cout</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>22、属于析构函数特征的是（　　）。</h3>
    <ul>
    <li>A、一个类中只有一个析构函数</li><li>B、析构函数的名字与类名不同</li><li>C、析构函数可以重载</li><li>D、析构函数可以有多个参数</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>23、在面向对象的程序设计中，使用多态（　　）。</h3>
    <ul>
    <li>A、既不能增强程序的可扩充性，也不能精简代码</li><li>B、能增强程序的可扩充性，也能精简代码</li><li>C、不能增强程序的可扩充性，能精简代码</li><li>D、不能精简代码，能增强程序的可扩充性</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>24、C++语言与C语言相比，在求解问题方法上进行的最大改进是（　　）。</h3>
    <ul>
    <li>A、面向过程</li><li>B、面向对象</li><li>C、安全性</li><li>D、复用性</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>25、下列关于类的析构函数的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、能带形式参数</li><li>B、函数体中必须有delete语句</li><li>C、可以被重载</li><li>D、无形参，也不可重载</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>26、派生类从基类保护继承时，基类中的私有成员在派生类中是隐藏的，（　　）访问。（填写可以或者不可以）</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：不可以</h3>
  </div>

  <div class='item'>
    <h3 class='title'>27、定义4个类，类A中定义公有成员函数Print()为虚函数，类A派生了类B和类D，类B派生了类C， 3个派生类均是公有继承也都重写了Print()函数，则有（　　）个派生类中的Print()是虚函数。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：3</h3>
  </div>

  <div class='item'>
    <h3 class='title'>28、程序语句“A::A(int  a, int  *b) { this->x= a; this->y=b;}"中，this  的类型是（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>29、在C++中，变量的三个基本要素是指：变量名、变量类型和（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：变量值</h3>
  </div>

  <div class='item'>
    <h3 class='title'>30、假定不允许使用逻辑非操作符，则关系表达式x+y >5的相反表达式为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：x+y <=5</h3>
  </div>

  <div class='item'>
    <h3 class='title'>31、要将str=”2023c++"，输出为“!!!2023c++"，应使用语句 "cout <<setfill('! ') （　　）"。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：<<setw(10)<<str;</h3>
  </div>

  <div class='item'>
    <h3 class='title'>32、类和对象之间的关系是抽象和具体的关系，类是对多个对象进行综合抽象的结果，对象是类的（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：实例</h3>
  </div>

  <div class='item'>
    <h3 class='title'>33、对象成员是指该对象所属类中定义的成员，包括数据成员和（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：成员函数</h3>
  </div>

  <div class='item'>
    <h3 class='title'>34、已知类A中的两个成员函数f1()和f2()，如果在fl()中不能直接调用f2()，则（　　）是静态函数。（只填写函数名）</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：f1</h3>
  </div>

  <div class='item'>
    <h3 class='title'>35、因为类的成员函数之间是可以互相调用的，所以在普通成员函数中调用其他虚成员函数也是允许的，并且是（　　）的。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：多态</h3>
  </div>

  <div class='item'>
    <h3 class='title'>36、运算符++、+=、+、[]中，只能用成员函数重载的运算符是（　　）和[ ]。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：=</h3>
  </div>

  <div class='item'>
    <h3 class='title'>37、若有定义int  a=3;则执行完语句a+=a-=a*a;之后，a的值为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：-12</h3>
  </div>

  <div class='item'>
    <h3 class='title'>38、假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：AB::bb</h3>
  </div>

  <div class='item'>
    <h3 class='title'>39、OOA中使用（　　）映射问题域中的事物。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：对象</h3>
  </div>

  <div class='item'>
    <h3 class='title'>40、使用类模板创建对象时，要随类模板名给出对应于类型形参或普通形参的具体实参，可以使用格式“类模板名 <（　　）参数表 > 对象名1, ...对象名n;”。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：模板</h3>
  </div>

  <div class='item'>
    <h3 class='title'>41、“封装”要求一个对象应具备明确的（　　），并具有接口以便和其他对象相互作用。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：功能</h3>
  </div>

  <div class='item'>
    <h3 class='title'>42、在面向对象的程序设计中，将一组对象的共同特性抽象出来形成（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：类</h3>
  </div>

  <div class='item'>
    <h3 class='title'>43、在面向对象的程序设计方法中，将同一类事物的共同特点概括出来，这个过程叫作（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：抽象</h3>
  </div>

  <div class='item'>
    <h3 class='title'>44、如果一个派生类只有一个唯一的基类，则称这样的继承关系为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：单继承</h3>
  </div>

  <div class='item'>
    <h3 class='title'>45、在一个C++程序文件中，若要包含另外一个头文件或程序文件，则应使用以（　　）标识符开始的预处理命令。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：#include</h3>
  </div>

  <div class='item'>
    <h3 class='title'>46、

                                              #include  <iostream >
                                              using  namespace  std;
                                              class  Test{
                                              private:int  x,y;
                                              public:
                                              Test(int  i,int  j){
                                              x=i;
                                              y=j;
                                              }
                                              int  getx(){return  x;}
                                              int  gety(){return  y;}
                                              int  getz(){swap(x,y);return  x%y;}
                                              };
                                              int  main()
                                              {
                                              Test  mt(2023,10);
                                              cout <<mt.getx();
                                              cout <<mt.gety()<<endl;
                                              cout <<"交换后取余的值为: "<<mt.getz()<<endl;
                                              return  0;
                                              }</h3>
    <ul>

    </ul>
    <h3 class='answer'>
                                              参考答案：202310交换后取余的值为：10
                                          </h3>
  </div>

  <div class='item'>
    <h3 class='title'>1、通过下列哪一选项调用虚函数，会采用动态联编（　　）。</h3>
    <ul>
    <li>A、对象指针</li><li>B、对象名</li><li>C、成员名限定</li><li>D、派生类名</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>3、假设对A类定义一个重载“+”号运算符的成员函数，以便实现两个A类对象的加法，并返回相加结果，则该成员函数的函数原型是（　　）。</h3>
    <ul>
    <li>A、operator  +( const  A  &A1, const  A  &A2)</li><li>B、A::operator  +( A  &A2  )</li><li>C、AA:: operator  +( const  A  & A2)</li><li>D、AA::operator  +()</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>4、下列关于重载流插入和流提取运算符的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、不可以对流插入运算符进行重载</li><li>B、不可以对流提取运算符进行重载</li><li>C、重载函数不能是流类库中的成员</li><li>D、流是标准类库用户能继承也能修改</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>5、定义了指向常量的指针p的选项是（　　）。</h3>
    <ul>
    <li>A、const  int  *p;</li><li>B、int  *p;</li><li>C、int  * const  p  = &x;</li><li>D、const  int  * const  p  = &x;</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>6、下列打开文件的语句中，错误的是（　　）。</h3>
    <ul>
    <li>A、ofstream  ofile;ofile.open("abc.txt ",ios::binary);</li><li>B、fstream  iofile;iofile.open("abc.txt " ios:ate);</li><li>C、cout.open("abc.txt ",ios:binary);</li><li>D、ifstream  ifile  ("abc.txt ");</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>7、下列关于封装特点的描述中，错误的是（　　）。</h3>
    <ul>
    <li>A、隐藏对象的属性</li><li>B、公开实现的细节</li><li>C、提供使用的信息</li><li>D、公开的信息是与外界交互的接口</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>10、下列关于类的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、基类具有派生类的特征</li><li>B、一个类只能有一个父类</li><li>C、“has  a "关系表示类的继承机制</li><li>D、"is  a "关系具有传递性</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>11、以下函数声明，正确的是（　　）。</h3>
    <ul>
    <li>A、void  func1(int  a=1, int  b, int  c=3);</li><li>B、void  defaultvalue1(int  a=2, double  b);</li><li>C、void  func2(int  a=1, int  b= 2, int  0);</li><li>D、void  defaultvalue2(int  a, double  b=3.0);</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>13、下列对C++语言的描述中，错误的是（　　）。</h3>
    <ul>
    <li>A、以.cpp  作为文件扩展名</li><li>B、程序运行的总入口是函数main()</li><li>C、主函数可以调用其他自定义函数</li><li>D、注释有三种形式//、/...*/、 < < .. .>></li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>14、下列对于语句 "freopen(“records.txt ", "r ",stdin);"的分析中，正确的是（　　）。</h3>
    <ul>
    <li>A、“freopen "为文件名</li><li>B、“recrds.txt "是重定向函数名</li><li>C、“r”代表重定向为“写”方式</li><li>D、将cin重定向到文件records.txt</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>15、下列关于对象数组的描述中，错误的是（　　）。</h3>
    <ul>
    <li>A、对象数组的下标是从0开始的</li><li>B、对象数组的数组名是一个常量指针</li><li>C、对象数组的每个元素是同一个类的对象</li><li>D、对象数组只能赋初值，不能被赋值</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>19、使用setprecision()函数时必须包含的头文件是（　　）。</h3>
    <ul>
    <li>A、iomanip</li><li>B、ctime</li><li>C、ifstream</li><li>D、fstream</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>20、下列关于类模板的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、类模板必须有多种类型参数</li><li>B、可以使用类模板直接生成对象</li><li>C、类模板实例化后才可以创建对象</li><li>D、类模板之间不允许继承</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>21、关于成员函数特征的描述中，错误的是（　　）。</h3>
    <ul>
    <li>A、成员函数一定是内联函数</li><li>B、成员函数可以重载</li><li>C、成员函数可以设置参数的缺省值</li><li>D、成员函数可以是静态的</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>22、假设Class  Y  : public  X，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为（　　）。</h3>
    <ul>
    <li>A、X,Y;Y,X</li><li>B、X,Y;X,Y</li><li>C、Y,X;X,Y</li><li>D、Y,X;Y,X</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>23、派生类的对象可以访问的其基类成员是（　　）。</h3>
    <ul>
    <li>A、公有继承的公有成员</li><li>B、公有继承的私有成员</li><li>C、公有继承的保护成员</li><li>D、私有继承的公有成员</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>24、下列选项中是引用调用的为（　　）。</h3>
    <ul>
    <li>A、形参是指针，实参是地址值</li><li>B、形参和实参都是变量</li><li>C、形参是引用，实参是变量</li><li>D、形参是变量，实参是引用</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>27、如果要定义二元组类，则需要根据组成二元组的类型定义很多不同的类，此时最好使用（　　）来解决问题。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：类模板</h3>
  </div>

  <div class='item'>
    <h3 class='title'>30、变量分为全局和局部两种，（　　）变量没有赋初值时，其值是不确定的。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：局部</h3>
  </div>

  <div class='item'>
    <h3 class='title'>31、已知 'A '-'Z '的ASCI码为65-90，当执行char  ch  = 14  * 5  + 2;cout <<ch <<endl;语句序列后，得到的输出结果为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：H</h3>
  </div>

  <div class='item'>
    <h3 class='title'>33、文件的I/O由ifstream、（　　）和fstream三个类提供。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：ofstream</h3>
  </div>

  <div class='item'>
    <h3 class='title'>35、派生类从基类中可以继承成员变量，普通的成员函数，但不能继承构造函数和（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：析构函数</h3>
  </div>

  <div class='item'>
    <h3 class='title'>37、在定义类的对象时，C++程序将自动调用该对象的（　　）函数初始化对象自身。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：构造</h3>
  </div>

  <div class='item'>
    <h3 class='title'>38、构造函数是类中特殊的成员函数，其功能是在（　　）时使用给定的值来初始化对象。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：创建对象</h3>
  </div>

  <div class='item'>
    <h3 class='title'>39、通常根据是否可以直接操纵计算机底层硬件，将程序设计语言分为低级语言、中级语言和（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：高级语言</h3>
  </div>

  <div class='item'>
    <h3 class='title'>40、C++根据文件数据的编码方式不同分为（　　）和二进制文件。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：文本文件</h3>
  </div>

  <div class='item'>
    <h3 class='title'>41、要将s=“C++”输出为“@@@C++”这样的格式，应该使用的语句是 "cout <<（　　）<<setw(6)<<s;"。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：setfill('@')</h3>
  </div>

  <div class='item'>
    <h3 class='title'>43、设opr表示要重载的运算符，那么重载运算符的函数名是（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：operator opr</h3>
  </div>

  <div class='item'>
    <h3 class='title'>44、AB是一个类，那么执行语句AB  a(4), b[3], *p;时，调用构造函数的次数是（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：4</h3>
  </div>

  <div class='item'>
    <h3 class='title'>46、

                                              #include  <iostream >
                                              using  namespace  std;
                                              static  int  grade  = 7;
                                              void  func()
                                              {
                                              Int  a= 1;
                                              static  int  b=l;
                                              a+=2;b+=2;grade=2;
                                              }
                                              int  main()
                                              {
                                              int  score=100;
                                              for(int  i=l; i <=3;++)
                                              func();
                                              cout <<"grade  is  "<<grade <<endl;
                                              cout <<"score  is  "<<score <<endl;
                                              return  0;
                                              }</h3>
    <ul>

    </ul>
    <h3 class='answer'>
                                              参考答案：grade is 1score is 100
                                          </h3>
  </div>

  <div class='item'>
    <h3 class='title'>7、以下派生方式中，能让派生类访问基类中的protected成员的是（　　）。</h3>
    <ul>
    <li>A、public  和protected</li><li>B、public  和private</li><li>C、private  和protected</li><li>D、仅public</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>11、下列对派生类的描述中，错误的是（　　）。</h3>
    <ul>
    <li>A、对基类成员的访问必须是无二义性</li><li>B、派生类至少有一个基类</li><li>C、基类的公有成员在派生类中仍然是公有的</li><li>D、派生类的成员除了它自己的成员外，还包含了它的基类的成员</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>12、若有char  C= 'a '，则语句 "cout.put(C+25); "的执行结果是（　　）。</h3>
    <ul>
    <li>A、输出整数122</li><li>B、输出字符z</li><li>C、输出整数97</li><li>D、输出字符a</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>13、作用城运算符 "::"的功能是（　　）。</h3>
    <ul>
    <li>A、标识作用域的级别</li><li>B、指出作用城的范围</li><li>C、给定作用域的大小</li><li>D、标识成员是属于哪个类</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>14、对于下面类定义，正确的叙述是（　　）。
                                          class  A{
                                          public: virtual  void  funcl（　　）{ }
                                          void  func2(){ } };
                                          class  B:public  A{
                                          public: void  func1（　　）{cout <<" class  B  func  1 " <<end;}
                                          virtual  void  func2（　　）{cout <<" class  B  func  2 " <<endl;};</h3>
    <ul>
    <li>A、A::func2( )和B::func1( )都是虚函数</li><li>B、A::func2()和B::func1()都不是虚函数</li><li>C、B::funcl( )是虚函数，而A::func2( )不是虛函数</li><li>D、B:funcl()不是虚函数，而A::func2()是虛函数</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>16、下列格式控制符中，既可以用于输入，又可以用于输出的是（　　）。</h3>
    <ul>
    <li>A、setbase</li><li>B、setfill</li><li>C、setprecision</li><li>D、setw</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>20、当一个类的某个函数被声明为virtual时，该函数在该类的所有派生类中（　　）。</h3>
    <ul>
    <li>A、都是虚函数</li><li>B、只有被重新声明时才是虚函数</li><li>C、只有被重新声明为virtual时才是虚函数</li><li>D、都不是虚函数</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>25、设类Test将其他类对象作为成员，则创建类Test的对象时，下列描述正确的是（　　）。</h3>
    <ul>
    <li>A、先执行类的构造函数</li><li>B、先执行成员对象的构造函数</li><li>C、先执行类的析构函数</li><li>D、先执行成员对象的析构函数</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>34、静态成员函数、友元函数、构造函数和析构函数中，不属于成员函数的是（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：友元函数</h3>
  </div>

  <div class='item'>
    <h3 class='title'>37、所谓（　　）成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：私有</h3>
  </div>

  <div class='item'>
    <h3 class='title'>40、面向对象的程序设计方法使得程序结构清晰，相互协作容易，更重要的是程序的（　　）性大大提升了。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：复用</h3>
  </div>

  <div class='item'>
    <h3 class='title'>41、如果运算符被重载为类的成员函数，对于（　　）元运算符只需要传递一个参数。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：二 或 2</h3>
  </div>

  <div class='item'>
    <h3 class='title'>42、重载赋值运算符后，赋值语句的功能是将一个对象中指针成员变量指向的内容复制到另一个对象中指针成员变量指向的地方，这样的拷贝叫“（　　）”。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：深拷贝</h3>
  </div>

  <div class='item'>
    <h3 class='title'>43、函数模板中紧随template之后尖括号内的类型参数都要冠以保留字（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：class</h3>
  </div>

  <div class='item'>
    <h3 class='title'>45、运算符重载相当于定义了一个以（　　）为名称的函数。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：运算符</h3>
  </div>

  <div class='item'>
    <h3 class='title'>1、"class  Demo{public:void  SetValue(){}};"，主函数中有语句“const  Demo  Obj; Obj.SetValue();”，正确的说法是（　　）。</h3>
    <ul>
    <li>A、Obj是常量对象</li><li>B、SetValue()函数值为整型</li><li>C、const  Demo  Obj;编译时错误</li><li>D、Obj.SetValue();编译时正确</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>2、重载流提取运算符的一般格式是（　　）。</h3>
    <ul>
    <li>A、ostream  &operator >>(ostream  & output,类名 &对象名){...}</li><li>B、ostream  &operator <<(ostream  & output,类名 &对象名){...}</li><li>C、istream  &operator >>(istream  & input,类名 &对象名){...}</li><li>D、istream  &operator <<(istream  & input,类名 &对象名){...}</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>13、如果类PrintInfo要重载流插入运算符，则重载函数参数表的形式一般定义为（　　）。</h3>
    <ul>
    <li>A、(ostream &)</li><li>B、(const  PrintInfo &)</li><li>C、(ostream &, const  PrintInfo  &)</li><li>D、(const  PrintInfo &,ostream &)</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>19、打开文件时要指明文件的使用方式，下列说法中错误的是（　　）。</h3>
    <ul>
    <li>A、只读或只写</li><li>B、既读又写</li><li>C、在文件开始追加数据</li><li>D、在文件末尾追加数据</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>24、不属于类ifstream和fstream的成员函数get()的主要形式的选项是（　　）。</h3>
    <ul>
    <li>A、int  get();</li><li>B、istream & get(char  &rch);</li><li>C、istream & get(char  &rch,ostream::write);</li><li>D、istream & get(char  *pch,int  nCount,char  delim='\n ');</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>28、在C++函数的形参前加const关键字，是为了提高函数的（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：可维护性</h3>
  </div>

  <div class='item'>
    <h3 class='title'>35、假定要动态分配一个类型为Worker的具有n个元素的数组，并由r指向这个动态数组，则使用的语句表达式为Worker  *r=（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：new Worker[n];</h3>
  </div>

  <div class='item'>
    <h3 class='title'>38、定义类时，保护成员的访问范围比（　　）成员的访问范围大。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：私有</h3>
  </div>

  <div class='item'>
    <h3 class='title'>40、C++中有两种继承，一种是单继承，另一种是（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：多重继承</h3>
  </div>

  <div class='item'>
    <h3 class='title'>42、在C++程序中使用基本输入与输出流时需要包含的头文件名是（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：iostream</h3>
  </div>

  <div class='item'>
    <h3 class='title'>1、下列关于派生类对象的初始化叙述中，正确的是（　　）。</h3>
    <ul>
    <li>A、是由基类的构造函数实现的</li><li>B、是由派生类的构造函数实现的</li><li>C、是由基类和派生类的构造函数实现的</li><li>D、是系统自动完成的不需程序设计者干预</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>2、下面对模板的声明正确的是（　　）。</h3>
    <ul>
    <li>A、template  class <S1,S2 ></li><li>B、template <class  S1,S2 ></li><li>C、template <class  S1;class  S2 ></li><li>D、template <class  S1,class  S2 ></li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>4、下列关于友元函数描述中，不正确的是（　　）。</h3>
    <ul>
    <li>A、可以被声明为const</li><li>B、不属于成员函数</li><li>C、可以用类名或对象名来调用</li><li>D、只能用对象名来调用</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>12、有定义“Demo  & Demo::operato++(){...returm  *this;}”，若obj是类Demo的对象，则以下描述错误的是（　　）。</h3>
    <ul>
    <li>A、自增运算符“++”可以被重载</li><li>B、函数可以区分前置及后置情况</li><li>C、++obj  等价于obj.operator++</li><li>D、obj++等价于obj.operator++()</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>14、下列关于访问范围说明符public、private、protected的描述中，正确的是（　　）。</h3>
    <ul>
    <li>A、每种关键字至少出现1次</li><li>B、不加说明符默认为公有的</li><li>C、3种关键字出现的先后次序没有限制</li><li>D、成员的访问范围由它之后最近的说明符决定</li>
    </ul>
    <h3 class='answer'>参考答案：C</h3>
  </div>

  <div class='item'>
    <h3 class='title'>19、实现两个相同类型数加法的函数模板的声明可以是（　　）。</h3>
    <ul>
    <li>A、T  add(T  x,T  y)</li><li>B、T  add(T  x,y)</li><li>C、T  add(x,y)</li><li>D、add(T  x,T  y)</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>23、在C++中打开一个文件就是将指定的文件与下列（　　）选项建立关联。</h3>
    <ul>
    <li>A、流对象</li><li>B、流类</li><li>C、流函数</li><li>D、流结构</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>27、通过对象访问成员变量的一般格式为“对象名. （　　）名”。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：成员变量</h3>
  </div>

  <div class='item'>
    <h3 class='title'>32、定义重载函数，应该在参数类型或（　　）上有所不同。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：个数</h3>
  </div>

  <div class='item'>
    <h3 class='title'>33、类模板 "template <class  T >classX{...};"，其中友元函数f对特定类型T(如int)，使函数f(X <int >&)成为X <int >模板类的友元，则其说明应为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：friend void f(X <T >&);</h3>
  </div>

  <div class='item'>
    <h3 class='title'>39、数学表达式“3(f-32)÷2”，写成对应的C++的表达式为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：3*(f-32)/2</h3>
  </div>

  <div class='item'>
    <h3 class='title'>46、

                                              #include  <iostream >
                                              using  namespace  std;
                                              class  A{
                                              public:virtual  void  ShowO  const  { cout  << "A::Show()" << endl;}
                                              };
                                              class  B: public  A{
                                              public:void  Show  const  { cout  << "B::Show()" << endl; }
                                              };
                                              void  Refers(const  A  &obj){obj.Show();}
                                              int  main()
                                              {
                                              A  obj1;
                                              B  obj2;
                                              Refers(obj1);
                                              Refers(obj2);
                                              return  0;
                                                  }</h3>
    <ul>

    </ul>
    <h3 class='answer'>
                                              参考答案：A::Show()B::Show()
                                          </h3>
  </div>

  <div class='item'>
    <h3 class='title'>5、下列关于模板的说法中，正确的是（　　）。</h3>
    <ul>
    <li>A、模板的实参在任何时候都可以省略</li><li>B、类模板与模板类所指的是同一概念</li><li>C、类模板的参数必须是虚拟类型的</li><li>D、类模板中的成员函数全部都是模板函数</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>11、在C++现有类的基础上可以声明新的类，若将原有类中的数据和函数保留，又加上自己特殊的数据和函数，从而构成一个新类，则下列说法正确的是（　　）。</h3>
    <ul>
    <li>A、原有的类是基类，也称为父类或超类</li><li>B、新类是基类，也称为子类</li><li>C、父类派生了子类，或者说父类继承于子类</li><li>D、派生类只能从基类继承成员，无法定义更多的成员</li>
    </ul>
    <h3 class='answer'>参考答案：A</h3>
  </div>

  <div class='item'>
    <h3 class='title'>41、有些情况下，基类中的某个虚函数给不出或者没必要给出详细的定义，可以将它声明为一个（　　）函数。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：纯虚</h3>
  </div>

  <div class='item'>
    <h3 class='title'>10、在派生类也是封闭类的情况下，说法错误的是（　　）。</h3>
    <ul>
    <li>A、构造函数的初始化列表要指明基类对象和成员对象的初始化方式</li><li>B、生成派生类对象时，根据派生层次从上至下依次执行所有基类的构造函数</li><li>C、按照成员对象的定义顺序执行各个成员对象所属类的构造函数</li><li>D、派生类对象消亡时，执行析构函数的次序与执行构造函数的次序相同</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>35、模板类型形参表使用的关键字为（　　）。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：class</h3>
  </div>

  <div class='item'>
    <h3 class='title'>11、假设类Studentclass为抽象类，下列语句中正确的是（　　）。</h3>
    <ul>
    <li>A、Studentclass  fun(int  )</li><li>B、Studentclass  Obj</li><li>C、int  fun(Studentclas)</li><li>D、Studentclass  *p</li>
    </ul>
    <h3 class='answer'>参考答案：D</h3>
  </div>

  <div class='item'>
    <h3 class='title'>24、下列选项中，能表现出C++语言的主要特点的是（　　）。</h3>
    <ul>
    <li>A、继承于C#语言</li><li>B、可以进行面向对象的程序设计</li><li>C、不能进行结构化程序设计</li><li>D、基于数据流的程序设计</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>28、重载运算符“[]”时，只能将它重载为（　　），不能重载为全局函数。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：成员函数</h3>
  </div>

  <div class='item'>
    <h3 class='title'>5、在类的继承关系中，基类成员在派生类中可见的是（　　）。</h3>
    <ul>
    <li>A、所有</li><li>B、public和protected</li><li>C、只有public</li><li>D、只有protected</li>
    </ul>
    <h3 class='answer'>参考答案：B</h3>
  </div>

  <div class='item'>
    <h3 class='title'>41、面向对象程序设计将表示属性特征的数据和对数据进行操作的（　　）封装在一起，构成一个完整的对象。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：方法</h3>
  </div>

  <div class='item'>
    <h3 class='title'>45、学生集合包含本科生集合，如果一个人是本科生，他/她必然也是一位学生，设计程序时，（　　）集合作为派生类。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：本科生</h3>
  </div>

  <div class='item'>
    <h3 class='title'>40、声明虚函数成员的一般格式为:“（　　）函数返回值类型  函数名(形参表); ”。</h3>
    <ul>

    </ul>
    <h3 class='answer'>参考答案：virtual</h3>
  </div>

</body>
</HTML>
